var express = require('express');
var router = express.Router();
var DateModule = require('../../databases/date');
const WebSocket = require('ws'); // 引入WebSocket模块
const http = require('http'); // 引入http模块

// 用于存储已连接的用户
var connectedUsers = new Map(); // 存储连接的用户信息

// 存储群聊信息
var chatRooms = {
  "公共群": { // 公共群聊房间
    id: "public",
    name: "公共群",
    messages: [], // 存储消息历史
    type: "group"
  },
  "技术交流": { // 技术交流群聊房间
    id: "tech",
    name: "技术交流",
    messages: [],
    type: "group"
  },
  "娱乐聊天": { // 娱乐聊天群聊房间
    id: "entertainment",
    name: "娱乐聊天",
    messages: [],
    type: "group"
  }
};

// 存储私聊消息
var privateMessages = {}; // 用于存储私聊消息历史

// 存储客户端心跳状态
var clientHeartbeats = new Map(); // 存储客户端最后一次心跳时间
const HEARTBEAT_INTERVAL = 30000; // 心跳间隔时间(ms)
const CONNECTION_TIMEOUT = 90000; // 连接超时时间(ms)，无心跳响应后判定断线

/* GET users listing. */
router.get('/', function(req, res, next) {
  res.send('respond with a resource');
});

// 创建WebSocket服务器
const setupWebSocketServer = (server) => {
  // 创建WebSocket服务器实例
  const wss = new WebSocket.Server({ server });

  // 设置心跳检测定时器
  const heartbeatChecker = setInterval(() => {
    const now = Date.now();
    
    // 检查所有客户端的心跳状态
    clientHeartbeats.forEach((lastHeartbeat, wsId) => {
      // 如果超过超时时间未收到心跳，认为客户端已断开
      if (now - lastHeartbeat > CONNECTION_TIMEOUT) {
        console.log(`客户端 ${wsId} 心跳超时，清理连接状态`);
        
        // 查找并关闭对应的WebSocket连接
        wss.clients.forEach(client => {
          if (client.id === wsId && client.readyState === WebSocket.OPEN) {
            console.log(`关闭超时客户端连接: ${wsId}`);
            client.terminate(); // 强制关闭连接
          }
        });
        
        // 清理心跳记录
        clientHeartbeats.delete(wsId);
      }
    });
  }, HEARTBEAT_INTERVAL);

  // 处理连接
  wss.on('connection', function(ws) {
    console.log("websocket连接成功"); // 记录连接成功日志
    
    // 为每个连接分配一个唯一ID
    ws.id = Date.now() + Math.random().toString(36).substr(2, 5); // 生成唯一ID
    
    // 记录客户端初始心跳时间
    clientHeartbeats.set(ws.id, Date.now());
    
    // 发送群聊和在线用户列表
    function sendRoomAndUserList() {
      // 获取在线用户列表（除了当前用户）
      const onlineUsers = Array.from(connectedUsers.entries())
        .filter(([username]) => username !== ws.username)
        .map(([username, data]) => ({
          id: username,  // 用用户名作为ID
          name: username,
          type: "private"
        }));
      
      // 合并群聊和用户列表
      const allRooms = [
        ...Object.values(chatRooms).map(room => ({
          id: room.id,
          name: room.name,
          type: "group"
        })),
        ...onlineUsers
      ];
      
      ws.send(JSON.stringify({
        type: "roomList",
        data: allRooms
      }));
    }
    
    // 连接成功后发送群聊列表
    sendRoomAndUserList(); // 初始化时发送列表
    
    // 接收消息
    ws.on('message', function(message) {
      console.log("收到消息"); // 记录收到消息日志
      
      let data;
      try {
        data = JSON.parse(message); // 解析消息内容
      } catch (e) {
        console.error("解析消息失败:", e); // 记录解析失败日志
        return;
      }
      
      // 更新客户端心跳时间
      clientHeartbeats.set(ws.id, Date.now());
      
      // 处理不同类型的消息
      switch(data.type) {
        case "heartbeat":
          // 处理心跳消息
          console.log(`接收到客户端 ${ws.id} 心跳: ${data.timestamp}`);
          // 响应心跳
          ws.send(JSON.stringify({
            type: "pong",
            timestamp: Date.now()
          }));
          break;
          
        case "join":
          // 用户加入群聊或开始私聊
          if(data.username && data.roomId) {
            // 保存用户信息和当前所在的房间
            ws.username = data.username;
            ws.roomId = data.roomId;
            ws.roomType = data.roomType || "group"; // 群聊或私聊
            
            if(!connectedUsers.has(data.username)) {
              connectedUsers.set(data.username, {
                connId: ws.id,
                roomId: data.roomId
              });
              
              // 广播新用户上线通知，更新所有用户的聊天列表
              broadcastUserListUpdate();
            } else {
              // 更新用户的房间
              connectedUsers.get(data.username).roomId = data.roomId;
            }
            
            if(ws.roomType === "group") {
              // 群聊：发送历史消息
              if(chatRooms[data.roomId]) {
                ws.send(JSON.stringify({
                  type: "history",
                  data: chatRooms[data.roomId].messages
                }));
                
                // 广播用户加入消息
                broadcast(JSON.stringify({
                  type: "message",
                  data: {
                    username: "系统",
                    content: `${data.username} 加入了群聊`,
                    time: new Date().toISOString(),
                    roomId: data.roomId
                  }
                }));
              }
            } else {
              // 私聊：发送历史消息
              const privateRoomId = getPrivateRoomId(data.username, data.roomId);
              if(privateMessages[privateRoomId]) {
                ws.send(JSON.stringify({
                  type: "history",
                  data: privateMessages[privateRoomId]
                }));
              } else {
                ws.send(JSON.stringify({
                  type: "history",
                  data: []
                }));
              }
            }
          }
          break;
          
        case "message":
          // 用户发送消息
          if(data.content && ws.username) {
            const messageObj = {
              username: ws.username,
              content: data.content,
              time: new Date().toISOString(),
              roomId: ws.roomId,
              roomType: ws.roomType,
              messageType: data.messageType || 'text' // 消息类型：text、voice 或 image
            };
            
            if(ws.roomType === "group") {
              // 群聊消息
              if(chatRooms[ws.roomId]) {
                chatRooms[ws.roomId].messages.push(messageObj);
                // 限制消息历史记录数量
                if(chatRooms[ws.roomId].messages.length > 100) {
                  chatRooms[ws.roomId].messages.shift();
                }
              }
              
              // 广播消息到所有连接的用户
              broadcast(JSON.stringify({
                type: "message",
                data: messageObj
              }));
            } else {
              // 私聊消息
              const targetUsername = ws.roomId; // 目标用户名
              const privateRoomId = getPrivateRoomId(ws.username, targetUsername);
              
              // 保存私聊消息
              if(!privateMessages[privateRoomId]) {
                privateMessages[privateRoomId] = [];
              }
              privateMessages[privateRoomId].push(messageObj);
              
              // 限制消息历史记录数量
              if(privateMessages[privateRoomId].length > 100) {
                privateMessages[privateRoomId].shift();
              }
              
              // 发送给发送者
              ws.send(JSON.stringify({
                type: "message",
                data: messageObj
              }));
              
              // 发送给接收者
              sendMessageToUser(targetUsername, JSON.stringify({
                type: "message",
                data: messageObj
              }));
            }
          }
          break;
          
        case "voice":
          // 处理语音消息
          if(data.audioData && ws.username) {
            const messageObj = {
              username: ws.username,
              content: data.audioData, // Base64编码的音频数据
              time: new Date().toISOString(),
              roomId: ws.roomId,
              roomType: ws.roomType,
              messageType: 'voice',
              duration: data.duration || 0 // 语音时长
            };
            
            if(ws.roomType === "group") {
              // 群聊语音消息
              if(chatRooms[ws.roomId]) {
                chatRooms[ws.roomId].messages.push(messageObj);
                // 限制消息历史记录数量
                if(chatRooms[ws.roomId].messages.length > 100) {
                  chatRooms[ws.roomId].messages.shift();
                }
              }
              
              // 广播语音消息到所有连接的用户
              broadcast(JSON.stringify({
                type: "message",
                data: messageObj
              }));
            } else {
              // 私聊语音消息
              const targetUsername = ws.roomId; // 目标用户名
              const privateRoomId = getPrivateRoomId(ws.username, targetUsername);
              
              // 保存私聊语音消息
              if(!privateMessages[privateRoomId]) {
                privateMessages[privateRoomId] = [];
              }
              privateMessages[privateRoomId].push(messageObj);
              
              // 限制消息历史记录数量
              if(privateMessages[privateRoomId].length > 100) {
                privateMessages[privateRoomId].shift();
              }
              
              // 发送给发送者
              ws.send(JSON.stringify({
                type: "message",
                data: messageObj
              }));
              
              // 发送给接收者
              sendMessageToUser(targetUsername, JSON.stringify({
                type: "message",
                data: messageObj
              }));
            }
          }
          break;
          
        case "image":
          // 处理图片消息
          if(data.imageData && ws.username) {
            const messageObj = {
              username: ws.username,
              content: data.imageData, // Base64编码的图片数据
              time: new Date().toISOString(),
              roomId: ws.roomId,
              roomType: ws.roomType,
              messageType: 'image',
              imageInfo: data.imageInfo || {} // 图片信息（宽度、高度等）
            };
            
            if(ws.roomType === "group") {
              // 群聊图片消息
              if(chatRooms[ws.roomId]) {
                chatRooms[ws.roomId].messages.push(messageObj);
                // 限制消息历史记录数量
                if(chatRooms[ws.roomId].messages.length > 100) {
                  chatRooms[ws.roomId].messages.shift();
                }
              }
              
              // 广播图片消息到所有连接的用户
              broadcast(JSON.stringify({
                type: "message",
                data: messageObj
              }));
            } else {
              // 私聊图片消息
              const targetUsername = ws.roomId; // 目标用户名
              const privateRoomId = getPrivateRoomId(ws.username, targetUsername);
              
              // 保存私聊图片消息
              if(!privateMessages[privateRoomId]) {
                privateMessages[privateRoomId] = [];
              }
              privateMessages[privateRoomId].push(messageObj);
              
              // 限制消息历史记录数量
              if(privateMessages[privateRoomId].length > 100) {
                privateMessages[privateRoomId].shift();
              }
              
              // 发送给发送者
              ws.send(JSON.stringify({
                type: "message",
                data: messageObj
              }));
              
              // 发送给接收者
              sendMessageToUser(targetUsername, JSON.stringify({
                type: "message",
                data: messageObj
              }));
            }
          }
          break;
          
        case "file":
          // 处理文件消息
          if(data.fileData && ws.username) {
            const messageObj = {
              username: ws.username,
              content: data.fileData, // Base64编码的文件数据
              time: new Date().toISOString(),
              roomId: ws.roomId,
              roomType: ws.roomType,
              messageType: 'file',
              fileInfo: data.fileInfo || {} // 文件信息（名称、大小、类型等）
            };
            
            if(ws.roomType === "group") {
              // 群聊文件消息
              if(chatRooms[ws.roomId]) {
                chatRooms[ws.roomId].messages.push(messageObj);
                // 限制消息历史记录数量
                if(chatRooms[ws.roomId].messages.length > 100) {
                  chatRooms[ws.roomId].messages.shift();
                }
              }
              
              // 广播文件消息到所有连接的用户
              broadcast(JSON.stringify({
                type: "message",
                data: messageObj
              }));
            } else {
              // 私聊文件消息
              const targetUsername = ws.roomId; // 目标用户名
              const privateRoomId = getPrivateRoomId(ws.username, targetUsername);
              
              // 保存私聊文件消息
              if(!privateMessages[privateRoomId]) {
                privateMessages[privateRoomId] = [];
              }
              privateMessages[privateRoomId].push(messageObj);
              
              // 限制消息历史记录数量
              if(privateMessages[privateRoomId].length > 100) {
                privateMessages[privateRoomId].shift();
              }
              
              // 发送给发送者
              ws.send(JSON.stringify({
                type: "message",
                data: messageObj
              }));
              
              // 发送给接收者
              sendMessageToUser(targetUsername, JSON.stringify({
                type: "message",
                data: messageObj
              }));
            }
          }
          break;
          
        case "video":
          // 处理视频消息
          if(data.videoData && ws.username) {
            const messageObj = {
              username: ws.username,
              content: data.videoData, // Base64编码的视频数据
              time: new Date().toISOString(),
              roomId: ws.roomId,
              roomType: ws.roomType,
              messageType: 'video',
              videoInfo: data.videoInfo || {} // 视频信息（时长、大小等）
            };
            
            if(ws.roomType === "group") {
              // 群聊视频消息
              if(chatRooms[ws.roomId]) {
                chatRooms[ws.roomId].messages.push(messageObj);
                // 限制消息历史记录数量
                if(chatRooms[ws.roomId].messages.length > 100) {
                  chatRooms[ws.roomId].messages.shift();
                }
              }
              
              // 广播视频消息到所有连接的用户
              broadcast(JSON.stringify({
                type: "message",
                data: messageObj
              }));
            } else {
              // 私聊视频消息
              const targetUsername = ws.roomId; // 目标用户名
              const privateRoomId = getPrivateRoomId(ws.username, targetUsername);
              
              // 保存私聊视频消息
              if(!privateMessages[privateRoomId]) {
                privateMessages[privateRoomId] = [];
              }
              privateMessages[privateRoomId].push(messageObj);
              
              // 限制消息历史记录数量
              if(privateMessages[privateRoomId].length > 100) {
                privateMessages[privateRoomId].shift();
              }
              
              // 发送给发送者
              ws.send(JSON.stringify({
                type: "message",
                data: messageObj
              }));
              
              // 发送给接收者
              sendMessageToUser(targetUsername, JSON.stringify({
                type: "message",
                data: messageObj
              }));
            }
          }
          break;
          
        case "getUserList":
          // 请求获取最新的用户列表
          if (ws.username) {
            // 只有已登录的用户才能获取列表
            sendRoomAndUserList();
          }
          break;
          
        case "login":
          // 用户登录
          if (data.username) {
            ws.username = data.username;
            
            // 将用户添加到连接用户列表
            if (!connectedUsers.has(data.username)) {
              connectedUsers.set(data.username, {
                connId: ws.id
              });
              
              // 广播新用户上线通知
              broadcastUserListUpdate();
            }
            
            // 发送群聊和用户列表给当前用户
            sendRoomAndUserList();
          }
          break;
      }
    });

    // 处理关闭连接
    ws.on('close', function() {
      console.log(`WebSocket连接关闭: ${ws.id}`);
      
      // 清理心跳记录
      clientHeartbeats.delete(ws.id);
      
      if(ws.username) {
        if(ws.roomType === "group" && ws.roomId) {
          // 广播用户离开群聊消息
          broadcast(JSON.stringify({
            type: "message",
            data: {
              username: "系统",
              content: `${ws.username} 离开了群聊`,
              time: new Date().toISOString(),
              roomId: ws.roomId
            }
          }));
        }
        
        // 从连接用户列表中移除
        connectedUsers.delete(ws.username);
        
        // 广播用户下线通知，更新所有用户的聊天列表
        broadcastUserListUpdate();
      }
    });

    // 处理错误
    ws.on('error', function(err) {
      console.log("websocket错误：", err); // 记录WebSocket错误
      
      // 清理心跳记录
      clientHeartbeats.delete(ws.id);
    });
  });

  // 在WebSocket服务器关闭时清理定时器
  wss.on('close', function() {
    clearInterval(heartbeatChecker);
    console.log('WebSocket服务器已关闭，心跳检测已停止');
  });

  // 生成私聊房间ID (确保两人之间的ID一致，无论谁发起私聊)
  function getPrivateRoomId(user1, user2) {
    return [user1, user2].sort().join('_'); // 排序确保相同两个用户的ID一致
  }

  // 向指定用户发送消息
  function sendMessageToUser(username, message) {
    wss.clients.forEach(function(client) {
      if(client.username === username && client.readyState === WebSocket.OPEN) {
        client.send(message); // 向特定用户发送消息
      }
    });
  }

  // 广播用户列表更新
  function broadcastUserListUpdate() {
    wss.clients.forEach(function(client) {
      if(client.username && client.readyState === WebSocket.OPEN) {
        // 为每个用户发送更新后的列表
        const onlineUsers = Array.from(connectedUsers.entries())
          .filter(([username]) => username !== client.username)
          .map(([username, data]) => ({
            id: username,
            name: username,
            type: "private"
          }));
        
        const allRooms = [
          ...Object.values(chatRooms).map(room => ({
            id: room.id,
            name: room.name,
            type: "group"
          })),
          ...onlineUsers
        ];
        
        client.send(JSON.stringify({
          type: "roomList",
          data: allRooms
        }));
      }
    });
  }

  // 向指定房间广播消息
  function broadcastToRoom(roomId, message) {
    wss.clients.forEach(function(client) {
      if(client.roomId === roomId && client.readyState === WebSocket.OPEN) {
        client.send(message); // 向特定房间的所有用户发送消息
      }
    });
  }

  // 广播给所有连接
  function broadcast(message) {
    wss.clients.forEach(function(client) {
      if(client.readyState === WebSocket.OPEN) {
        client.send(message); // 向所有连接的用户发送消息
      }
    });
  }

  return wss; // 返回WebSocket服务器实例
};

// 导出WebSocket服务器设置函数，在app.js中将使用
router.setupWebSocketServer = setupWebSocketServer;

module.exports = router;